package com.neuedu.his.controller;

import com.neuedu.his.po.Constanttype;
import com.neuedu.his.service.ConstanttypeService;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;

import java.util.List;

/**
 * 常量类型控制器
 * 提供常量类型的增删改查功能
 */
@RestController
@RequestMapping("/constanttype")
public class ConstantTypeController {
    private static final Logger log = LoggerFactory.getLogger(ConstantTypeController.class);

    @Autowired
    private ConstanttypeService service;

    /**
     * 添加常量类型
     */
    @PostMapping("/add")
    public boolean add(@RequestBody Constanttype type) {
        log.info("请求添加常量类型:{}", type);
        try {
            // 校验必要字段
            if (type.getConstanttypename() == null || type.getConstanttypename().trim().isEmpty()) {
                log.warn("常量类型名称为空，添加失败");
                return false;
            }
            if (type.getConstanttypecode() == null || type.getConstanttypecode().trim().isEmpty()) {
                log.warn("常量类型编码为空，添加失败");
                return false;
            }

            return service.save(type);
        } catch (Exception e) {
            log.error("添加常量类型失败", e);
            return false;
        }
    }

    /**
     * 删除常量类型
     */
    @DeleteMapping("/delete/{id}")
    public boolean delete(@PathVariable Integer id) {
        log.info("请求删除ID为{}的常量类型", id);
        try {
            // 校验ID有效性
            if (id == null || id <= 0) {
                log.warn("无效的ID:{}，删除失败", id);
                return false;
            }

            // 物理删除（直接删除数据）
            boolean success = service.removeById(id);

            // 逻辑删除（更新delmark字段）
            /*Constanttype type = new Constanttype();
            type.setId(id);
            type.setDelmark(1); // 1表示已删除
            boolean success = service.updateById(type);*/

            return success;
        } catch (Exception e) {
            log.error("删除常量类型失败", e);
            return false;
        }
    }

    /**
     * 修改常量类型
     */
    @PutMapping("/update")
    public boolean update(@RequestBody Constanttype type) {
        log.info("请求修改常量类型:{}", type);
        try {
            // 校验必要字段
            if (type.getId() == null || type.getId() <= 0) {
                log.warn("ID为空或无效，修改失败");
                return false;
            }
            if (type.getConstanttypename() == null || type.getConstanttypename().trim().isEmpty()) {
                log.warn("常量类型名称为空，修改失败");
                return false;
            }
            if (type.getConstanttypecode() == null || type.getConstanttypecode().trim().isEmpty()) {
                log.warn("常量类型编码为空，修改失败");
                return false;
            }

            return service.updateById(type);
        } catch (Exception e) {
            log.error("修改常量类型失败", e);
            return false;
        }
    }

    /**
     * 根据ID查询常量类型
     */
    @GetMapping("/get/{id}")
    public Constanttype get(@PathVariable Integer id) {
        log.info("请求查询ID为{}的常量类型", id);
        try {
            if (id == null || id <= 0) {
                log.warn("无效的ID:{}，查询失败", id);
                return null;
            }
            return service.getById(id);
        } catch (Exception e) {
            log.error("查询常量类型失败", e);
            return null;
        }
    }

    /**
     * 查询所有常量类型（排除已删除）
     */
    @GetMapping("/list")
    public List<Constanttype> list() {
        log.info("请求查询所有常量类型");
        try {
            // 构建查询条件：delmark=0（未删除）
            /*QueryWrapper<Constanttype> queryWrapper = new QueryWrapper<>();
            queryWrapper.eq("DelMark", 0);
            return service.list(queryWrapper);*/

            // 直接查询所有（包含已删除）
            return service.list();
        } catch (Exception e) {
            log.error("查询常量类型列表失败", e);
            return null;
        }
    }
}